SherbyNet - /page/wikibook/entry.mu

Micron Document

<!DOCTYPE html>

<title>Variable-length array</title>

</head>

Variable-length array

</h1>

</header>

In <a href="Computer_programming" title="Computer programming">computer programming</a>, a variable-length array (VLA), also called variable-sized or runtime-sized, is an <a href="Array_data_structure" class="mw-redirect" title="Array data structure">array data structure</a> whose length is determined at <a href="Execution_(computing)#Runtime" title="Execution (computing)">runtime</a>, instead of at <a href="Compile_time" title="Compile time">compile time</a>.<a href="#cite_note-cray-1">[1]</a> In the language <a href="C_(programming_language)" title="C (programming language)">C</a>, the VLA is said to have a variably modified <a href="Data_type" title="Data type">data type</a> that depends on a value (see <a href="Dependent_type" title="Dependent type">Dependent type</a>).

The main purpose of VLAs is to simplify programming of <a href="Numerical_method" title="Numerical method">numerical algorithms</a>.

Programming languages that support VLAs include <a href="Ada_(programming_language)" title="Ada (programming language)">Ada</a>, <a href="ALGOL_68" title="ALGOL 68">ALGOL 68</a> (for non-flexible rows), <a href="APL_(programming_language)" title="APL (programming language)">APL</a>, <a href="C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a> (as unsafe-mode <a href="Stack-based_memory_allocation" title="Stack-based memory allocation">stack-allocated</a> arrays), <a href="COBOL" title="COBOL">COBOL</a>, <a href="Fortran" title="Fortran">Fortran</a> 90, <a href="J_(programming_language)" title="J (programming language)">J</a>, and <a href="Object_Pascal" title="Object Pascal">Object Pascal</a> (the language used in <a href="Delphi_(software)" title="Delphi (software)">Delphi</a> and <a href="Lazarus_(software)" title="Lazarus (software)">Lazarus</a>, that uses FPC). <a href="C99" title="C99">C99</a> introduced support for VLAs, although they were subsequently relegated in <a href="C11_(C_standard_revision)" title="C11 (C standard revision)">C11</a> to a conditional feature, which implementations are not required to support;<a href="#cite_note-2">[2]</a><a href="#cite_note-3">[3]</a> on some platforms, VLAs could be implemented formerly with <code><a href="Alloca" class="mw-redirect" title="Alloca">alloca</a>()</code> or similar functions.

Growable arrays (also called <a href="Dynamic_array" title="Dynamic array">dynamic arrays</a>) are generally more useful than VLAs because dynamic arrays can do everything VLAs can do, and also support growing the array at run-time. For this reason, many programming languages (<a href="JavaScript" title="JavaScript">JavaScript</a>, <a href="Java_(programming_language)" title="Java (programming language)">Java</a>, <a href="Python_(programming_language)" title="Python (programming language)">Python</a>, <a href="R_(programming_language)" title="R (programming language)">R</a>, etc.) only support growable arrays. Even in languages that support variable-length arrays, it's often recommended to avoid using (stack-based) variable-length arrays, and instead use (<a href="Heap_(data_structure)" title="Heap (data structure)">heap-based</a>) dynamic arrays.<a href="#cite_note-4">[4]</a>

<div class="mw-heading mw-heading2"><h2 id="Memory">Memory</h2></div>

<div class="mw-heading mw-heading3"><h3 id="Allocation">Allocation</h3></div>

<ul><li>The <a href="GNU_Compiler_Collection" title="GNU Compiler Collection">GNU Compiler Collection</a> (GCC) for C allocates memory for VLAs with <a href="Automatic_variable" title="Automatic variable">automatic storage duration</a> on the <a href="Stack-based_memory_allocation" title="Stack-based memory allocation">stack</a>.<a href="#cite_note-5">[5]</a> This is the faster and more straightforward option compared to heap-allocation, and is used by most compilers.</li>

<li>VLAs can also be allocated on the <a href="Memory_management#Manual_memory_management" title="Memory management">heap</a> and internally accessed using a pointer to this block.</li></ul>

<div class="mw-heading mw-heading2"><h2 id="Implementation">Implementation</h2></div>

The following <a href="C99" title="C99">C99</a> function allocates a variable-length array of a specified size, fills it with floating-point values, and then passes it to another function for processing. Because the array is declared as an automatic variable, its lifetime ends when <code>read_and_process()</code> returns.

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre>float read_and_process(int n)

{

float vals[n];

for (int i = 0; i < n; ++i)

vals[i] = read_val();

return process(n, vals);

}

</pre></div>

In C99, the length parameter must come before the variable-length array parameter in function calls.<a href="#cite_note-cray-1">[1]</a> In C11, a <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">__STDC_NO_VLA__</code> macro is defined if VLA is not supported.<a href="#cite_note-6">[6]</a> The C23 standard makes VLA types mandatory again. Only creation of VLA objects with automatic storage duration is optional.<a href="#cite_note-7">[7]</a> GCC had VLA as an extension before C99, one that also extends into its C++ dialect.

<a href="Linus_Torvalds" title="Linus Torvalds">Linus Torvalds</a> has expressed his displeasure in the past over VLA usage for arrays with predetermined small sizes because it generates lower quality assembly code.<a href="#cite_note-8">[8]</a> With the Linux 4.20 kernel, the <a href="Linux_kernel" title="Linux kernel">Linux kernel</a> is effectively VLA-free.<a href="#cite_note-9">[9]</a>

Although C11 does not explicitly name a size-limit for VLAs, some believe it should have the same maximum size as all other objects, i.e. SIZE_MAX bytes.<a href="#cite_note-10">[10]</a> However, this should be understood in the wider context of environment and platform limits, such as the typical stack-guard page size of 4 KiB, which is many orders of magnitude smaller than SIZE_MAX.

It is possible to have VLA object with dynamic storage by using a pointer to an array.

{

float (*vals)[n] = malloc(sizeof(float[n]));

(*vals)[i] = read_val();

float ret = process(n, *vals);

free(vals);

return ret;

}

</pre></div>

The following is the same example in <a href="Ada_(programming_language)" title="Ada (programming language)">Ada</a>. Ada arrays carry their bounds with them, so there is no need to pass the length to the Process function.

<div class="mw-highlight mw-highlight-lang-ada mw-content-ltr" dir="ltr"><pre>type Vals_Type is array (Positive range <>) of Float;

function Read_And_Process (N : Integer) return Float is

Vals : Vals_Type (1 .. N);

begin

for I in 1 .. N loop

Vals (I) := Read_Val;

end loop;

return Process (Vals);

end Read_And_Process;

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Fortran_90">Fortran 90</h3></div>

The equivalent <a href="Fortran" title="Fortran">Fortran 90</a> function is

<div class="mw-highlight mw-highlight-lang-fortran mw-content-ltr" dir="ltr"><pre>function read_and_process(n) result(o)

integer,intent(in)::n

real::o

real,dimension(n)::vals

integer::i

do i = 1,n

vals(i) = read_val()

end do

o = process(vals)

end function read_and_process

</pre></div>

when utilizing the Fortran 90 feature of checking procedure interfaces at compile time; on the other hand, if the functions use pre-Fortran 90 call interface, the (external) functions must first be declared, and the array length must be explicitly passed as an argument (as in C):

real::o

real::read_val, process

integer::i

end do

end function read_and_process

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Cobol">Cobol</h3></div>

The following <a href="COBOL" title="COBOL">COBOL</a> fragment declares a variable-length array of records <code>DEPT-PERSON</code> having a length (number of members) specified by the value of <code>PEOPLE-CNT</code>:

<div class="mw-highlight mw-highlight-lang-cobolfree mw-content-ltr" dir="ltr"><pre>DATA DIVISION.

WORKING-STORAGE SECTION.

01 DEPT-PEOPLE.

05 PEOPLE-CNT PIC S9(4) BINARY.

05 DEPT-PERSON OCCURS 0 TO 20 TIMES DEPENDING ON PEOPLE-CNT.

10 PERSON-NAME PIC X(20).

10 PERSON-WAGE PIC S9(7)V99 PACKED-DECIMAL.

</pre></div>

The <a href="COBOL" title="COBOL">COBOL</a> VLA, unlike that of other languages mentioned here, is safe because COBOL requires specifying maximum array size. In this example, <code>DEPT-PERSON</code> cannot have more than 20 items, regardless of the value of <code>PEOPLE-CNT</code>.

The following <a href="C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a> fragment declares a variable-length array of integers. Before C# version 7.2, a pointer to the array is required, requiring an "unsafe" context. The "unsafe" keyword requires an assembly containing this code to be marked as unsafe.

<div class="mw-highlight mw-highlight-lang-csharp mw-content-ltr" dir="ltr"><pre>unsafe void DeclareStackBasedArrayUnsafe(int size)

{

int* p = stackalloc int[size];

p[0] = 123;

}

</pre></div>

C# version 7.2 and later allow the array to be allocated without the "unsafe" keyword, through the use of the Span feature.<a href="#cite_note-11">[11]</a>

<div class="mw-highlight mw-highlight-lang-csharp mw-content-ltr" dir="ltr"><pre>void DeclareStackBasedArraySafe(int size)

{

Span<int> a = stackalloc int[size];

a[0] = 123;

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Object_Pascal">Object Pascal</h3></div>

<a href="Object_Pascal" title="Object Pascal">Object Pascal</a> dynamic arrays are allocated on the heap.<a href="#cite_note-12">[12]</a>

In this language, it is called a dynamic array. The declaration of such a variable is similar to the declaration of a static array, but without specifying its size. The size of the array is given at the time of its use.

<div class="mw-highlight mw-highlight-lang-delphi mw-content-ltr" dir="ltr"><pre>program CreateDynamicArrayOfNumbers(Size: Integer);

var

NumberArray: array of LongWord;

begin

SetLength(NumberArray, Size);

NumberArray[0] := 2020;

end.

</pre></div>

Removing the contents of a dynamic array is done by assigning it a size of zero.

<div class="mw-highlight mw-highlight-lang-delphi mw-content-ltr" dir="ltr"><pre>...

SetLength(NumberArray, 0);

...

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}

/* end https://en.wikipedia.org/ */

</style><div class="reflist">

/* start https://en.wikipedia.org/ */

.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}

/* end https://en.wikipedia.org/ */

</style><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20180126153326/http://docs.cray.com/books/004-2179-001/html-004-2179-001/z893434830malz.html">"Variable Length Arrays"</a>. Archived from <a rel="nofollow" class="external text" href="http://docs.cray.com/books/004-2179-001/html-004-2179-001/z893434830malz.html">the original</a> on 2018-01-26.</cite>

</li>

<li id="cite_note-2"><a href="#cite_ref-2">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://gcc.gnu.org/onlinedocs/gcc/Variable-Length.html">"Variable Length – Using the GNU Compiler Collection (GCC)"</a>.</cite>

</li>

<li id="cite_note-3"><a href="#cite_ref-3">^</a> ISO 9899:2011 Programming Languages – C 6.7.6.2 4.

</li>

<li id="cite_note-4"><a href="#cite_ref-4">^</a> <cite id="CITEREFRaymond2000" class="citation web cs1">Raymond, Eric S. (2000). <a rel="nofollow" class="external text" href="https://tldp.org/HOWTO/Software-Release-Practice-HOWTO/develpractice.html">"Raymond Software Release Practice Howto: 6. Good development practice"</a>. The Linux Documentation Project.</cite>

</li>

<li id="cite_note-5"><a href="#cite_ref-5">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://gcc.gnu.org/onlinedocs/gfortran/Code-Gen-Options.html">"Code Gen Options - The GNU Fortran Compiler"</a>.</cite>

</li>

<li id="cite_note-6"><a href="#cite_ref-6">^</a> § 6.10.8.3 of the C11 standard (n1570.pdf)

</li>

<li id="cite_note-7"><a href="#cite_ref-7">^</a> § 6.10.9.3 of the C23 standard (n3054.pdf)

</li>

<li id="cite_note-8"><a href="#cite_ref-8">^</a> <cite id="CITEREFTorvalds2018" class="citation mailinglist cs1"><a href="Linus_Torvalds" title="Linus Torvalds">Torvalds, Linus</a> (7 March 2018). <a rel="nofollow" class="external text" href="https://lkml.org/lkml/2018/3/7/621">"LKML: Linus Torvalds: Re: VLA removal (was Re: [RFC 2/2] lustre: use VLA_SAFE)"</a>. Linux kernel (Mailing list).</cite>

</li>

<li id="cite_note-9"><a href="#cite_ref-9">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://www.phoronix.com/scan.php?page=news_item&px=Linux-Kills-The-VLA">"The Linux Kernel Is Now VLA-Free: A Win For Security, Less Overhead & Better For Clang - Phoronix"</a>. www.phoronix.com.</cite>

</li>

<li id="cite_note-10"><a href="#cite_ref-10">^</a> §6.5.3.4 and §7.20.3 of the C11 standard (n1570.pdf)

</li>

<li id="cite_note-11"><a href="#cite_ref-11">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/stackalloc">"stackalloc operator (C# reference)"</a>. Microsoft. 10 July 2024.</cite>

</li>

Michaël Van Canneyt.

<a rel="nofollow" class="external text" href="https://www.freepascal.org/docs-html/ref/refsu14.html#x38-520003.3.1">"Free Pascal Reference guide: Dynamic arrays"</a>.

</li>

</ol></div></div></div><div><div class="zim-footer">

This article is issued from <a class="external text" title="Last edited on 2025-08-06" href="https://en.wikipedia.org/wiki/?title=Variable-length_array&oldid=1304450677">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.

</div>

</div></div>

</div>

</main>

</div>

</body></html>